Συναρτησιακοί τελεστές
Apply, Map, 
Nest, NestList,
Fold, FoldList, 
FixedPoint, FixedPointList

Clear["`*"];

Apply[f,{a,b,c}]
f@@{a,b,c}

Apply[Plus,{a,b,c}]
Plus@@{a,b,c}

Nest[f,a,3]
NestList[f,a,3]

Fold[f,a,{b,c,d}]
FoldList[f,a,{b,c,d}]

Μέθοδος Newton για την επαναληπτική λύση της f[x] = 0  
 n[f,a] = a - f[a]/f'[a]

Clear[f,step]

f[x_]=x^2-5x+6;

step[f_,x_] := x - f[x]/f'[x]

NestList[step[f,#]&,3.5,5]
NestList[step[f,#]&,1.5,5]

NestList[Evaluate[step[f,#]]&,1.5,1000];//Timing

NestList[step[f,#]&,1.5,1000];//Timing

Με χρήση της FixedPoint και της  FixedPointList   
( επιλογή SameTest για τέλος).

FixedPoint[step[f,#]&,1.5]

FixedPoint[step[f,#]&,1.5,2]

FixedPoint[step[f,#]&,1.5,SameTest->(Abs[#1-#2]<.1&)]

FixedPointList[step[f,#]&,1.5,
	5, SameTest->(Abs[#1-#2]<.1&)
] (* ≤ 3 steps or abs change in vals is <.1*)

FixedPointList[step[f,#]&,1.5,
	5, SameTest->(Abs[#1-#2]<.01&)
]  (* ≤ 3 steps or abs change in vals is <.1*)

Άλλο Παράδειγμα

Εστω μία λίστα με μηνιαία κέρδη

profit={18, 97, 24, -13, -12, 80, -7, 90, 61, -14, 55, 85};

Υπολογίζουμε το τρέχων κέρδος

Χρήση FoldList,Prepend, Drop,...

sumlist=FoldList[Plus[#1,#2]&,First[profit], Rest[profit]]

sumlist - Prepend[ Drop[sumlist,-1],0]

Partition[Prepend[sumlist,0], 2,1]

Map[#[[2]]-#[[1]]&,%]

Δεικτοφόρες μεταβλητές - Array
(Για πίνακες χρησιμοποιουμε την Table)

Array[a,10]

Array[b,10,0]

lc=Array[c,5]

a[3]=100;b[3]=200;

?a

?b

?c

c[1]=300; c[5]=700;

lc

c[x_]:=Sin[x]^2;

lc

f[i_]:=1/i!;

Apply[Plus,Array[x^# * f[#] &, 9,0]]

Series[Exp[x],{ x,0,8}]

Πρότυπα

h[i_]:=10Prime[i+1]

h[3]

p1=Sum[h[i] x^(2i),{i,0,5}]

p1 /. x->z

p1 /. c_*x^e_ -> c/(3e) * x^(e+1)

p1 /. c_.*x^e_. -> c/(3e) * x^(e+1)

10 /. c_.*x^e_. -> (c+1) * x^(e+1)

p1

const=Select[p1, FreeQ[#,x_Symbol]&]

p1+a

Replace[p1, {c_  /; FreeQ[c,x] -> 7*c},1]

?*Q

x_,  x:_

FullForm[x:_]

n=.

name:expr

name:patternexpr			Pattern[name, expr]

{1,A[1,2], A[3,x],C[2,-Pi],A[4,E]}  /. n:A[1,2]-> B[n]

n

{1,A[1,2], A[3,x],C[2,-Pi],A[4,E]}  /. n:A[_,_]-> B[n]

t[x___Integer]:=Plus[x]

t[]

Blank	_,   __h,   x__h

_  	  μια expr					Blank[]
	__	  μια ή περισσότερες  exprs			BlankSequence[]
	___	  μηδέν ή περισσότερες exprs			BlankNullSequence[]
	_h	  μία expr με κεφαλή  h			Blank[h]
	__h	  μια ή περισσότερες με κεφαλή  h			BlankSequence[h]
	___h	  μεδέν ή περισσότερες με κεφαλή  h			BlankNullSequence[h]
	
	x__h 	      η παράσταση ανατίθεται στο x                         Το ίδιο με 	x:__h

{1,A[1,2], A[3,x],C[2,-Pi],A[4,E]} /. n_A-> B[n]

Εναλλακτικά πρότυπα	a|b|c

e1|...|ek	      εναλλακτικά  ei 		Alternatives[e1,e2...ek]

{a,b,c,d}/. a|c|e ->2

Τεστ προτύπου		pattern?test

pattern?test			PatternTest[pattern, test]

• test  	–  Μία παράσταση ταιριάζει στο πρότυπο μόνο άν το τέστ επιστρέψει True
	 	 		–  pattern?(body&);
	•  pattern 	–  πρότυπο

{1,2,3,4,5,6,7,8,9,10}/. _?EvenQ->0

{0,2}/.{__?Positive} ->9
{1,2}/.{__?Positive} ->9

{0,2}/.{_ ..?Positive} ->9 (* χρειάζεται space μετά το _ *)
{1,2}/.{_ ..?Positive} ->9

{}/.{_ ..?Positive} ->9

{}/.{_ ...?Positive} ->9  (* δεν υπάρχει μη αρνητικός στο {}*)
{}/.{___?Positive} ->9	  (*            ,,                  *)

Συνθήκη	expr/;condition

expr/;condition	 		Condition[expr, condition]
	η παράσταση εκτιμάται εφόσον η condition είναι  True

{{1,a,1,2},{1,a,1}} /.
	{x__,a,y__}/; Length[{x}] < Length[{y}] ->A[y]

Trace[{1,2,1,1,2,1}//.{x___,a_,b_,y___}/;a>b ->{x,b,a,y}]

{1,2,1,1,2,1}/.{x___,a_,b_,y___}/;a>b ->{x,b,a,y}

Επαναλαμβανόμενες παραστάσεις	expr..  ,  expr...

expr..		μία η περισσότερες  expr 	Repeated[expr]
expr...		μηδέν ή περισσότερες  expr     RepeatedNull[expr]

{a[x],a[y], a[z]}   /. {n:a[_]..} ->B[n ]

{a[x],a[y], a[z]}   /. n:a[_] ->B[n ]

{a[x],{a[y], a[z]}}   /. n:{a[_]..} ->B[n ]

{a[x],a[y]}  /.  {x:a[_]..} ->B[x]

Συναρτήσεις με πρότυπα

Cases, Select, Position, Count, DeleteCases

lst={1,2,z^E,x,a,7/3, Pi,Sin[x], Cos[x], x^3,-3, x^8, -19}

Cases[lst, _[_]]

Cases[lst, _Integer]

Cases[lst, x^n_]

Cases[lst, _^n_]

Cases[lst, _^n_->w^n]

Clear[hypot,hypot1,hypot2]

hypot[{x_Real ,y_Real}]:=Sqrt[x^2+y^2]/;(( 0≤x≤1) && ( 0<=y≤1))

hypot1[{x_Real ,y_Real}/;(( 0≤x≤1) && ( 0<=y≤1))]:=Sqrt[x^2+y^2]

hypot2[{x_Real ,y_Real}?(Function[v,(( 0≤v[[1]]<=1) && ( 0≤v[[2]]<=1))])]:=Sqrt[x^2+y^2]

hypot3[{x_Real ,y_Real}?((( 0≤#[[1]]<=1) && ( 0≤#[[2]]<=1))&)]:=Sqrt[x^2+y^2]

hypot3[{0.5,0.8}]

Trace[hypot3[{0.5,0.8}]]

?hypot3

Περιορισμός παραμέτρων

Clear[addOnes]
addOnes[list_List] := Append[Prepend[list,1],1]
addOnes[s_String] := StringJoin["1",s,"1"]
addOnes[i_Integer] := 1 + i + 1

addOnes["Program"]
addOnes[{4,6,4}]
addOnes[50]

Clear[addOnes]
addOnes[list_List] := Append[Prepend[list,1],1]
addOnes[i_?NumberQ] := 1 + i + 1
addOnes[s_?((StringQ[#]&&StringLength[#]>8)&)] :=
                        StringJoin[s," and so on"]

addOnes[{4,6,4}]
addOnes["Program"]
addOnes["Dogs and cats"]
addOnes[45.4]
addOnes[23]

Clear[addOnes]
addOnes[list_List] := Append[Prepend[list,1],1]

addOnes[list_?(!ListQ[#]&)] :=
                        Print["Parameter not a list!"]

addOnes[{4,6,4}]
addOnes[4]

Clear[addOnes]
addOnes[list_List] := Append[Prepend[list,1],1]
addOnes[i_?NumberQ] := 1 + i + 1
addOnes[x_] := Print["Parameter \"",x,"\" is not list or number!"]

addOnes[{2,3}]
addOnes[10]
addOnes["abc"]

Trace[addOnes["abc"]]

?addOnes

Clear[fac]
fac[0] := 1;
fac[1] := 1 ;
fac[n_] := n fac[n-1]

5!

Factorial[5]

fac[5]

Trace[fac[3]]

Trace[fac[3],fac]

Clear[fac];
fac[0] = 1;
fac[n_?((IntegerQ[#]&&(#>0))&)] := n fac[n-1];
fac[n_] := Print["The argument \"",n,
        "\" is not a positive integer."]

fac[-5]

fac[5+7I]

Clear[fac];
fac[0] = 1;
fac[n_Integer?((#>0)&)] := n fac[n-1];
fac[n_]:=Print["The argument \"",n,
          "\" is not a positive integer."]

fac[-5]

fac[5]

n=11

(2/4)!

Gamma[11/3]

((n/2)!)===Gamma[n/2+1]

Gamma[2.5]

Factorial[1.5]

(* factorial function, using recursion *)

(* fac[n]=n fac[n-1], with base case fac[1]=1 *)

Clear[fac];

fac::usage=
        "fac[n] computes n! for positive integers n" ;

fac[1] = 1;

fac[n_Integer?Positive] := n fac[n-1];
                        
fac[n_]:=  (* if not a positive integer *)
                        Print["The argument \"",n,
          "\" is not a positive integer."]

fac[10]

fac[-4]

?fac

??fac

Clear[ave];
ave[x_] := N[ Apply[ Plus, x ] / Length[x] ]

ave["Hello"]

ave[1,2,3]

ave[{1,2,3}]

Clear[ave];

ave::usage = "ave[list] finds a numeric approximation to the average of the
elements of the list";

ave[x_List] := N[ Apply[ Plus, x ] / Length[x] ];

ave[x_] :=
   Print["Your argument \"",x,"\" is not a list."];

ave["Hello"]

ave[1,2,3]

ave[{1,2,3}]

Clear[ave];

ave::usage = "ave[list] finds an real number approximation to the average
of the elements of the list";

ave[x_List] := N[ Apply[ Plus, x ] / Length[x] ];

ave[x___] := ave[{x}];

ave[x_] :=
   Print["Your argument \"",x,"\" is not a list."]

ave["Hello"]

ave[1,2,3]

ave[{1,2,3}]

?VectorQ

Clear[ave];

ave::usage = "ave[list] finds an real number approximation to the average
of the elements of the list";

ave[x_List] := N[ Apply[ Plus, x ] / Length[x] ];

ave[x___?NumberQ] := ave[{x}];

ave[x_] := Print["Your argument \"",x,"\" is not a list."];

ave["Hello"]

ave[1,2,3]

ave[{1,2,3}]

ave[{{a1,b1},{a2,b2},{a3,b3}}]

ave[{a1,a2,a3}]

Clear[ave];

ave::usage = "ave[list] finds an real number approximation to the average
of the elements of the list";

ave[x_List/;VectorQ[x, NumberQ]] := N[ Apply[ Plus, x ] / Length[x] ];

ave[x___?NumberQ] := ave[{x}];

ave[x_] := Print["Your argument \"",x,"\" is not a numeric list."];